home *** CD-ROM | disk | FTP | other *** search
/ Aminet 2 / Aminet AMIGA CDROM (1994)(Walnut Creek)[Feb 1994][W.O. 44790-1].iso / Aminet / gfx / edit / TSMrph23s.lha / TSM23s.lha / ilbmw.c < prev    next >
C/C++ Source or Header  |  1993-09-11  |  7KB  |  219 lines
  1. //    $Author: M_J_Paddock $
  2. //    $Date: 1992/08/08 01:05:42 $
  3. //    $Revision: 1.3 $
  4.  
  5. /*----------------------------------------------------------------------*
  6.  * ILBMW.C  Support routines for writing ILBM files using IFFParse.
  7.  * (IFF is Interchange Format File.)
  8.  *
  9.  * Based on code by Jerry Morrison and Steve Shaw, Electronic Arts.
  10.  * This software is in the public domain.
  11.  *
  12.  * This version for the Commodore-Amiga computer.
  13.  *
  14.  * mod 06-Apr-92 - Add JM change for separate source and dest modulo
  15.  *----------------------------------------------------------------------*/
  16. #define INTUI_V36_NAMES_ONLY
  17.  
  18. #include "iffp/ilbm.h"
  19. #include "iffp/packer.h"
  20.  
  21. #include <graphics/gfxbase.h>
  22.  
  23. extern struct Library *GfxBase;
  24.  
  25. /*---------- initbmhd -------------------------------------------------*/
  26. long initbmhd(BitMapHeader *bmhd, struct BitMap *bitmap,
  27.           WORD masking, WORD compression, WORD transparentColor,
  28.           WORD width, WORD height, WORD pageWidth, WORD pageHeight,
  29.           ULONG modeid)
  30.     {
  31.     extern struct Library *GfxBase;
  32.     struct DisplayInfo DI;
  33.  
  34.     WORD rowBytes = bitmap->BytesPerRow;
  35.  
  36.     D(bug("In InitBMHD\n"));
  37.  
  38.     bmhd->w = width;
  39.     bmhd->h = height;
  40.     bmhd->x = bmhd->y = 0;    /* Default position is (0,0).*/
  41.     bmhd->nPlanes = bitmap->Depth;
  42.     bmhd->masking = masking;
  43.     bmhd->compression = compression;
  44.     bmhd->reserved1 = 0;
  45.     bmhd->transparentColor = transparentColor;
  46.     bmhd->pageWidth = pageWidth;
  47.     bmhd->pageHeight = pageHeight;
  48.  
  49.     bmhd->xAspect = 0;    /* So we can tell when we've got it */
  50.     if(GfxBase->lib_Version >=36)
  51.     {
  52.        if(GetDisplayInfoData(NULL, (UBYTE *)&DI,
  53.         sizeof(struct DisplayInfo), DTAG_DISP, modeid))
  54.         {
  55.             bmhd->xAspect =  DI.Resolution.x;
  56.             bmhd->yAspect =  DI.Resolution.y;
  57.         }
  58.     }
  59.  
  60.     /* If running under 1.3 or GetDisplayInfoData failed, use old method
  61.      * of guessing aspect ratio
  62.      */
  63.     if(! bmhd->xAspect)
  64.     {
  65.         bmhd->xAspect =  44;
  66.         bmhd->yAspect =
  67.         ((struct GfxBase *)GfxBase)->DisplayFlags & PAL ? 44 : 52;
  68.         if(modeid & HIRES)    bmhd->xAspect = bmhd->xAspect >> 1;
  69.         if(modeid & LACE)    bmhd->yAspect = bmhd->yAspect >> 1;
  70.     }
  71.  
  72.     return( IS_ODD(rowBytes) ? CLIENT_ERROR : IFF_OKAY );
  73.     }
  74.  
  75. /*---------- putcmap ---------------------------------------------------*/
  76. /* This function will accept a table of color values in one of the
  77.  * following forms:
  78.  *  if bitspergun=4,  colortable is words, each with nibbles 0RGB
  79.  *  if bitspergun=8,  colortable is bytes of RGBRGB etc. (like a CMAP)
  80.  *  if bitspergun=32, colortable is ULONGS of RGBRGB etc.
  81.  *     (only the high eight bits of each gun will be written to CMAP)
  82.  */
  83. long putcmap(struct IFFHandle *iff, APTR colortable,
  84.          UWORD ncolors, UWORD bitspergun)
  85.    {
  86.    long error, offs;
  87.    WORD  *tabw;
  88.    UBYTE *tab8;
  89.    ColorRegister cmapReg;
  90.  
  91.    D(bug("In PutCMAP\n"));
  92.  
  93.    if((!iff)||(!colortable))    return(CLIENT_ERROR);
  94.  
  95.    /* size of CMAP is 3 bytes * ncolors */
  96.    if(error = PushChunk(iff, NULL, ID_CMAP, ncolors * sizeofColorRegister))
  97.     return(error);
  98.  
  99.    D(bug("Pushed ID_CMAP, error = %ld\n",error));
  100.  
  101.    if(bitspergun == 4)
  102.     {
  103.        /* Store each 4-bit value n as nn */
  104.     tabw = (UWORD *)colortable;
  105.        for( ;  ncolors;  --ncolors )
  106.         {
  107.               cmapReg.red    = ( *tabw >> 4 ) & 0xf0;
  108.               cmapReg.red   |= (cmapReg.red >> 4);
  109.  
  110.               cmapReg.green  = ( *tabw      ) & 0xf0;
  111.               cmapReg.green |= (cmapReg.green >> 4);
  112.  
  113.               cmapReg.blue   = ( *tabw << 4 ) & 0xf0;
  114.               cmapReg.blue  |= (cmapReg.blue >> 4);
  115.  
  116.               if((WriteChunkBytes(iff, (BYTE *)&cmapReg, sizeofColorRegister))
  117.                 != sizeofColorRegister)
  118.                         return(IFFERR_WRITE);
  119.               ++tabw;
  120.               }
  121.     }
  122.    else if((bitspergun == 8)||(bitspergun == 32))
  123.     {
  124.     tab8 = (UBYTE *)colortable;
  125.     offs = (bitspergun == 8) ? 1 : 4;
  126.        for( ;  ncolors;  --ncolors )
  127.         {
  128.         cmapReg.red   = *tab8;
  129.         tab8 += offs;
  130.         cmapReg.green = *tab8;
  131.         tab8 += offs;
  132.         cmapReg.blue  = *tab8;
  133.         tab8 += offs;
  134.               if((WriteChunkBytes(iff, (BYTE *)&cmapReg, sizeofColorRegister))
  135.                 != sizeofColorRegister)
  136.                         return(IFFERR_WRITE);
  137.         }
  138.     }
  139.    else (error = CLIENT_ERROR);
  140.  
  141.    D(bug("Wrote registers, error = %ld\n",error));
  142.  
  143.    error = PopChunk(iff);
  144.    return(error);
  145.    }
  146.  
  147. /*---------- putbody ---------------------------------------------------*/
  148. /* NOTE: This implementation could be a LOT faster if it used more of the
  149.  * supplied buffer. It would make far fewer calls to IFFWriteBytes (and
  150.  * therefore to DOS Write).
  151.  *
  152.  * Incorporates modification by Jesper Steen Moller to accept source
  153.  * rows are wider than dest rows, one for the source bitplanes
  154.  * and one for the ILBM bitmap.
  155.  */
  156. long putbody(struct IFFHandle *iff, struct BitMap *bitmap, BYTE *mask,
  157.          BitMapHeader *bmhd, BYTE *buffer, LONG bufsize)
  158.    {
  159.    long error;
  160.    LONG rowBytes = bitmap->BytesPerRow;
  161.    LONG FileRowBytes = RowBytes(bmhd->w);
  162.    int dstDepth = bmhd->nPlanes;
  163.    UBYTE compression = bmhd->compression;
  164.    int planeCnt;        /* number of bit planes including mask */
  165.    register int iPlane, iRow;
  166.    register LONG packedRowBytes;
  167.    BYTE *buf;
  168.    BYTE *planes[MAXSAVEDEPTH + 1]; /* array of ptrs to planes & mask */
  169.  
  170.    D(bug("In PutBODY, rows = %ld, rowBytes = %ld, expected %ld\n", bitmap->Rows, rowBytes, RowBytes(bmhd->w)));
  171.  
  172.    if ( bufsize < MaxPackedSize(rowBytes)  ||    /* Must buffer a comprsd row*/
  173.         compression > cmpByteRun1  ||        /* bad arg */
  174.     bitmap->Rows != bmhd->h   ||        /* inconsistent */
  175.     rowBytes < FileRowBytes  ||    /* inconsistent*/
  176.     bitmap->Depth < dstDepth   ||        /* inconsistent */
  177.     dstDepth > MAXSAVEDEPTH )        /* too many for this routine*/
  178.       return(CLIENT_ERROR);
  179.  
  180.    planeCnt = dstDepth + (mask == NULL ? 0 : 1);
  181.  
  182.    /* Copy the ptrs to bit & mask planes into local array "planes" */
  183.    for (iPlane = 0; iPlane < dstDepth; iPlane++)
  184.       planes[iPlane] = (BYTE *)bitmap->Planes[iPlane];
  185.    if (mask != NULL)
  186.       planes[dstDepth] = mask;
  187.  
  188.    /* Write out a BODY chunk header */
  189.    if(error = PushChunk(iff, NULL, ID_BODY, IFFSIZE_UNKNOWN)) return(error);
  190.  
  191.    /* Write out the BODY contents */
  192.    for (iRow = bmhd->h; iRow > 0; iRow--)  {
  193.       for (iPlane = 0; iPlane < planeCnt; iPlane++)  {
  194.  
  195.          /* Write next row.*/
  196.          if (compression == cmpNone) {
  197.         if(WriteChunkBytes(iff,planes[iPlane],FileRowBytes) != FileRowBytes)
  198.         error = IFFERR_WRITE;
  199.             planes[iPlane] += rowBytes; /* Possibly skipping unused bytes */
  200.             }
  201.  
  202.          /* Compress and write next row.*/
  203.          else {
  204.             buf = buffer;
  205.             packedRowBytes = packrow(&planes[iPlane], &buf, FileRowBytes);
  206.             planes[iPlane] += rowBytes-FileRowBytes; /* Possibly skipping unused bytes */
  207.         if(WriteChunkBytes(iff,buffer,packedRowBytes) != packedRowBytes)
  208.         error = IFFERR_WRITE;
  209.             }
  210.  
  211.          if(error)    return(error);
  212.          }
  213.       }
  214.  
  215.    /* Finish the chunk */
  216.    error = PopChunk(iff);
  217.    return(error);
  218.    }
  219.